/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Persistencia;

import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Logica.Garantia;
import Logica.Turno;
import Logica.Cliente;
import Logica.PedidoRepuesto;
import java.util.HashSet;
import java.util.Set;
import Logica.ReparacionEnEjecucion;
import java.util.ArrayList;
import java.util.List;
import Logica.Repuesto;
import Logica.EstadoVehiculo;
import Logica.Vehiculo;
import Persistencia.exceptions.NonexistentEntityException;
import Persistencia.exceptions.PreexistingEntityException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author Pablo
 */
public class VehiculoJpaController implements Serializable {
    
    public VehiculoJpaController(){
        emf = Persistence.createEntityManagerFactory("TpFinalPU");
    }

    public VehiculoJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Vehiculo vehiculo) throws PreexistingEntityException, Exception {
        if (vehiculo.getPedidos() == null) {
            vehiculo.setPedidos(new HashSet<PedidoRepuesto>());
        }
        if (vehiculo.getReparacionesEnEjecucion() == null) {
            vehiculo.setReparacionesEnEjecucion(new ArrayList<ReparacionEnEjecucion>());
        }
        if (vehiculo.getRespuestos() == null) {
            vehiculo.setRespuestos(new ArrayList<Repuesto>());
        }
        if (vehiculo.getEstados() == null) {
            vehiculo.setEstados(new ArrayList<EstadoVehiculo>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Garantia unaGarantia = vehiculo.getUnaGarantia();
            if (unaGarantia != null) {
                unaGarantia = em.getReference(unaGarantia.getClass(), unaGarantia.getNroGarantia());
                vehiculo.setUnaGarantia(unaGarantia);
            }
            Turno unTurno = vehiculo.getUnTurno();
            if (unTurno != null) {
                unTurno = em.getReference(unTurno.getClass(), unTurno.getNroTurno());
                vehiculo.setUnTurno(unTurno);
            }
            Cliente unCliente = vehiculo.getUnCliente();
            if (unCliente != null) {
                unCliente = em.getReference(unCliente.getClass(), unCliente.getNroDoc());
                vehiculo.setUnCliente(unCliente);
            }
            Set<PedidoRepuesto> attachedPedidos = new HashSet<PedidoRepuesto>();
            for (PedidoRepuesto pedidosPedidoRepuestoToAttach : vehiculo.getPedidos()) {
                pedidosPedidoRepuestoToAttach = em.getReference(pedidosPedidoRepuestoToAttach.getClass(), pedidosPedidoRepuestoToAttach.getNroPedido());
                attachedPedidos.add(pedidosPedidoRepuestoToAttach);
            }
            vehiculo.setPedidos(attachedPedidos);
            List<ReparacionEnEjecucion> attachedReparacionesEnEjecucion = new ArrayList<ReparacionEnEjecucion>();
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucionToAttach : vehiculo.getReparacionesEnEjecucion()) {
                reparacionesEnEjecucionReparacionEnEjecucionToAttach = em.getReference(reparacionesEnEjecucionReparacionEnEjecucionToAttach.getClass(), reparacionesEnEjecucionReparacionEnEjecucionToAttach.getNroReparacionEnEjecucion());
                attachedReparacionesEnEjecucion.add(reparacionesEnEjecucionReparacionEnEjecucionToAttach);
            }
            vehiculo.setReparacionesEnEjecucion(attachedReparacionesEnEjecucion);
            List<Repuesto> attachedRespuestos = new ArrayList<Repuesto>();
            for (Repuesto respuestosRepuestoToAttach : vehiculo.getRespuestos()) {
                respuestosRepuestoToAttach = em.getReference(respuestosRepuestoToAttach.getClass(), respuestosRepuestoToAttach.getCodigo());
                attachedRespuestos.add(respuestosRepuestoToAttach);
            }
            vehiculo.setRespuestos(attachedRespuestos);
            List<EstadoVehiculo> attachedEstados = new ArrayList<EstadoVehiculo>();
            for (EstadoVehiculo estadosEstadoVehiculoToAttach : vehiculo.getEstados()) {
                estadosEstadoVehiculoToAttach = em.getReference(estadosEstadoVehiculoToAttach.getClass(), estadosEstadoVehiculoToAttach.getCodigoEstado());
                attachedEstados.add(estadosEstadoVehiculoToAttach);
            }
            vehiculo.setEstados(attachedEstados);
            em.persist(vehiculo);
            if (unaGarantia != null) {
                Vehiculo oldUnVehiculoOfUnaGarantia = unaGarantia.getUnVehiculo();
                if (oldUnVehiculoOfUnaGarantia != null) {
                    oldUnVehiculoOfUnaGarantia.setUnaGarantia(null);
                    oldUnVehiculoOfUnaGarantia = em.merge(oldUnVehiculoOfUnaGarantia);
                }
                unaGarantia.setUnVehiculo(vehiculo);
                unaGarantia = em.merge(unaGarantia);
            }
            if (unTurno != null) {
                Vehiculo oldUnVehiculoOfUnTurno = unTurno.getUnVehiculo();
                if (oldUnVehiculoOfUnTurno != null) {
                    oldUnVehiculoOfUnTurno.setUnTurno(null);
                    oldUnVehiculoOfUnTurno = em.merge(oldUnVehiculoOfUnTurno);
                }
                unTurno.setUnVehiculo(vehiculo);
                unTurno = em.merge(unTurno);
            }
            if (unCliente != null) {
                unCliente.getVehiculos().add(vehiculo);
                unCliente = em.merge(unCliente);
            }
            for (PedidoRepuesto pedidosPedidoRepuesto : vehiculo.getPedidos()) {
                Vehiculo oldUnVehiculoOfPedidosPedidoRepuesto = pedidosPedidoRepuesto.getUnVehiculo();
                pedidosPedidoRepuesto.setUnVehiculo(vehiculo);
                pedidosPedidoRepuesto = em.merge(pedidosPedidoRepuesto);
                if (oldUnVehiculoOfPedidosPedidoRepuesto != null) {
                    oldUnVehiculoOfPedidosPedidoRepuesto.getPedidos().remove(pedidosPedidoRepuesto);
                    oldUnVehiculoOfPedidosPedidoRepuesto = em.merge(oldUnVehiculoOfPedidosPedidoRepuesto);
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucion : vehiculo.getReparacionesEnEjecucion()) {
                Vehiculo oldUnVehiculoOfReparacionesEnEjecucionReparacionEnEjecucion = reparacionesEnEjecucionReparacionEnEjecucion.getUnVehiculo();
                reparacionesEnEjecucionReparacionEnEjecucion.setUnVehiculo(vehiculo);
                reparacionesEnEjecucionReparacionEnEjecucion = em.merge(reparacionesEnEjecucionReparacionEnEjecucion);
                if (oldUnVehiculoOfReparacionesEnEjecucionReparacionEnEjecucion != null) {
                    oldUnVehiculoOfReparacionesEnEjecucionReparacionEnEjecucion.getReparacionesEnEjecucion().remove(reparacionesEnEjecucionReparacionEnEjecucion);
                    oldUnVehiculoOfReparacionesEnEjecucionReparacionEnEjecucion = em.merge(oldUnVehiculoOfReparacionesEnEjecucionReparacionEnEjecucion);
                }
            }
            for (Repuesto respuestosRepuesto : vehiculo.getRespuestos()) {
                Vehiculo oldUnVehiculoOfRespuestosRepuesto = respuestosRepuesto.getUnVehiculo();
                respuestosRepuesto.setUnVehiculo(vehiculo);
                respuestosRepuesto = em.merge(respuestosRepuesto);
                if (oldUnVehiculoOfRespuestosRepuesto != null) {
                    oldUnVehiculoOfRespuestosRepuesto.getRespuestos().remove(respuestosRepuesto);
                    oldUnVehiculoOfRespuestosRepuesto = em.merge(oldUnVehiculoOfRespuestosRepuesto);
                }
            }
            for (EstadoVehiculo estadosEstadoVehiculo : vehiculo.getEstados()) {
                Vehiculo oldUnVehiculoOfEstadosEstadoVehiculo = estadosEstadoVehiculo.getUnVehiculo();
                estadosEstadoVehiculo.setUnVehiculo(vehiculo);
                estadosEstadoVehiculo = em.merge(estadosEstadoVehiculo);
                if (oldUnVehiculoOfEstadosEstadoVehiculo != null) {
                    oldUnVehiculoOfEstadosEstadoVehiculo.getEstados().remove(estadosEstadoVehiculo);
                    oldUnVehiculoOfEstadosEstadoVehiculo = em.merge(oldUnVehiculoOfEstadosEstadoVehiculo);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findVehiculo(vehiculo.getNroChasis()) != null) {
                throw new PreexistingEntityException("Vehiculo " + vehiculo + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Vehiculo vehiculo) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Vehiculo persistentVehiculo = em.find(Vehiculo.class, vehiculo.getNroChasis());
            Garantia unaGarantiaOld = persistentVehiculo.getUnaGarantia();
            Garantia unaGarantiaNew = vehiculo.getUnaGarantia();
            Turno unTurnoOld = persistentVehiculo.getUnTurno();
            Turno unTurnoNew = vehiculo.getUnTurno();
            Cliente unClienteOld = persistentVehiculo.getUnCliente();
            Cliente unClienteNew = vehiculo.getUnCliente();
            Set<PedidoRepuesto> pedidosOld = persistentVehiculo.getPedidos();
            Set<PedidoRepuesto> pedidosNew = vehiculo.getPedidos();
            List<ReparacionEnEjecucion> reparacionesEnEjecucionOld = persistentVehiculo.getReparacionesEnEjecucion();
            List<ReparacionEnEjecucion> reparacionesEnEjecucionNew = vehiculo.getReparacionesEnEjecucion();
            List<Repuesto> respuestosOld = persistentVehiculo.getRespuestos();
            List<Repuesto> respuestosNew = vehiculo.getRespuestos();
            List<EstadoVehiculo> estadosOld = persistentVehiculo.getEstados();
            List<EstadoVehiculo> estadosNew = vehiculo.getEstados();
            if (unaGarantiaNew != null) {
                unaGarantiaNew = em.getReference(unaGarantiaNew.getClass(), unaGarantiaNew.getNroGarantia());
                vehiculo.setUnaGarantia(unaGarantiaNew);
            }
            if (unTurnoNew != null) {
                unTurnoNew = em.getReference(unTurnoNew.getClass(), unTurnoNew.getNroTurno());
                vehiculo.setUnTurno(unTurnoNew);
            }
            if (unClienteNew != null) {
                unClienteNew = em.getReference(unClienteNew.getClass(), unClienteNew.getNroDoc());
                vehiculo.setUnCliente(unClienteNew);
            }
            Set<PedidoRepuesto> attachedPedidosNew = new HashSet<PedidoRepuesto>();
            for (PedidoRepuesto pedidosNewPedidoRepuestoToAttach : pedidosNew) {
                pedidosNewPedidoRepuestoToAttach = em.getReference(pedidosNewPedidoRepuestoToAttach.getClass(), pedidosNewPedidoRepuestoToAttach.getNroPedido());
                attachedPedidosNew.add(pedidosNewPedidoRepuestoToAttach);
            }
            pedidosNew = attachedPedidosNew;
            vehiculo.setPedidos(pedidosNew);
            List<ReparacionEnEjecucion> attachedReparacionesEnEjecucionNew = new ArrayList<ReparacionEnEjecucion>();
            for (ReparacionEnEjecucion reparacionesEnEjecucionNewReparacionEnEjecucionToAttach : reparacionesEnEjecucionNew) {
                reparacionesEnEjecucionNewReparacionEnEjecucionToAttach = em.getReference(reparacionesEnEjecucionNewReparacionEnEjecucionToAttach.getClass(), reparacionesEnEjecucionNewReparacionEnEjecucionToAttach.getNroReparacionEnEjecucion());
                attachedReparacionesEnEjecucionNew.add(reparacionesEnEjecucionNewReparacionEnEjecucionToAttach);
            }
            reparacionesEnEjecucionNew = attachedReparacionesEnEjecucionNew;
            vehiculo.setReparacionesEnEjecucion(reparacionesEnEjecucionNew);
            List<Repuesto> attachedRespuestosNew = new ArrayList<Repuesto>();
            for (Repuesto respuestosNewRepuestoToAttach : respuestosNew) {
                respuestosNewRepuestoToAttach = em.getReference(respuestosNewRepuestoToAttach.getClass(), respuestosNewRepuestoToAttach.getCodigo());
                attachedRespuestosNew.add(respuestosNewRepuestoToAttach);
            }
            respuestosNew = attachedRespuestosNew;
            vehiculo.setRespuestos(respuestosNew);
            List<EstadoVehiculo> attachedEstadosNew = new ArrayList<EstadoVehiculo>();
            for (EstadoVehiculo estadosNewEstadoVehiculoToAttach : estadosNew) {
                estadosNewEstadoVehiculoToAttach = em.getReference(estadosNewEstadoVehiculoToAttach.getClass(), estadosNewEstadoVehiculoToAttach.getCodigoEstado());
                attachedEstadosNew.add(estadosNewEstadoVehiculoToAttach);
            }
            estadosNew = attachedEstadosNew;
            vehiculo.setEstados(estadosNew);
            vehiculo = em.merge(vehiculo);
            if (unaGarantiaOld != null && !unaGarantiaOld.equals(unaGarantiaNew)) {
                unaGarantiaOld.setUnVehiculo(null);
                unaGarantiaOld = em.merge(unaGarantiaOld);
            }
            if (unaGarantiaNew != null && !unaGarantiaNew.equals(unaGarantiaOld)) {
                Vehiculo oldUnVehiculoOfUnaGarantia = unaGarantiaNew.getUnVehiculo();
                if (oldUnVehiculoOfUnaGarantia != null) {
                    oldUnVehiculoOfUnaGarantia.setUnaGarantia(null);
                    oldUnVehiculoOfUnaGarantia = em.merge(oldUnVehiculoOfUnaGarantia);
                }
                unaGarantiaNew.setUnVehiculo(vehiculo);
                unaGarantiaNew = em.merge(unaGarantiaNew);
            }
            if (unTurnoOld != null && !unTurnoOld.equals(unTurnoNew)) {
                unTurnoOld.setUnVehiculo(null);
                unTurnoOld = em.merge(unTurnoOld);
            }
            if (unTurnoNew != null && !unTurnoNew.equals(unTurnoOld)) {
                Vehiculo oldUnVehiculoOfUnTurno = unTurnoNew.getUnVehiculo();
                if (oldUnVehiculoOfUnTurno != null) {
                    oldUnVehiculoOfUnTurno.setUnTurno(null);
                    oldUnVehiculoOfUnTurno = em.merge(oldUnVehiculoOfUnTurno);
                }
                unTurnoNew.setUnVehiculo(vehiculo);
                unTurnoNew = em.merge(unTurnoNew);
            }
            if (unClienteOld != null && !unClienteOld.equals(unClienteNew)) {
                unClienteOld.getVehiculos().remove(vehiculo);
                unClienteOld = em.merge(unClienteOld);
            }
            if (unClienteNew != null && !unClienteNew.equals(unClienteOld)) {
                unClienteNew.getVehiculos().add(vehiculo);
                unClienteNew = em.merge(unClienteNew);
            }
            for (PedidoRepuesto pedidosOldPedidoRepuesto : pedidosOld) {
                if (!pedidosNew.contains(pedidosOldPedidoRepuesto)) {
                    pedidosOldPedidoRepuesto.setUnVehiculo(null);
                    pedidosOldPedidoRepuesto = em.merge(pedidosOldPedidoRepuesto);
                }
            }
            for (PedidoRepuesto pedidosNewPedidoRepuesto : pedidosNew) {
                if (!pedidosOld.contains(pedidosNewPedidoRepuesto)) {
                    Vehiculo oldUnVehiculoOfPedidosNewPedidoRepuesto = pedidosNewPedidoRepuesto.getUnVehiculo();
                    pedidosNewPedidoRepuesto.setUnVehiculo(vehiculo);
                    pedidosNewPedidoRepuesto = em.merge(pedidosNewPedidoRepuesto);
                    if (oldUnVehiculoOfPedidosNewPedidoRepuesto != null && !oldUnVehiculoOfPedidosNewPedidoRepuesto.equals(vehiculo)) {
                        oldUnVehiculoOfPedidosNewPedidoRepuesto.getPedidos().remove(pedidosNewPedidoRepuesto);
                        oldUnVehiculoOfPedidosNewPedidoRepuesto = em.merge(oldUnVehiculoOfPedidosNewPedidoRepuesto);
                    }
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionOldReparacionEnEjecucion : reparacionesEnEjecucionOld) {
                if (!reparacionesEnEjecucionNew.contains(reparacionesEnEjecucionOldReparacionEnEjecucion)) {
                    reparacionesEnEjecucionOldReparacionEnEjecucion.setUnVehiculo(null);
                    reparacionesEnEjecucionOldReparacionEnEjecucion = em.merge(reparacionesEnEjecucionOldReparacionEnEjecucion);
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionNewReparacionEnEjecucion : reparacionesEnEjecucionNew) {
                if (!reparacionesEnEjecucionOld.contains(reparacionesEnEjecucionNewReparacionEnEjecucion)) {
                    Vehiculo oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion = reparacionesEnEjecucionNewReparacionEnEjecucion.getUnVehiculo();
                    reparacionesEnEjecucionNewReparacionEnEjecucion.setUnVehiculo(vehiculo);
                    reparacionesEnEjecucionNewReparacionEnEjecucion = em.merge(reparacionesEnEjecucionNewReparacionEnEjecucion);
                    if (oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion != null && !oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion.equals(vehiculo)) {
                        oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion.getReparacionesEnEjecucion().remove(reparacionesEnEjecucionNewReparacionEnEjecucion);
                        oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion = em.merge(oldUnVehiculoOfReparacionesEnEjecucionNewReparacionEnEjecucion);
                    }
                }
            }
            for (Repuesto respuestosOldRepuesto : respuestosOld) {
                if (!respuestosNew.contains(respuestosOldRepuesto)) {
                    respuestosOldRepuesto.setUnVehiculo(null);
                    respuestosOldRepuesto = em.merge(respuestosOldRepuesto);
                }
            }
            for (Repuesto respuestosNewRepuesto : respuestosNew) {
                if (!respuestosOld.contains(respuestosNewRepuesto)) {
                    Vehiculo oldUnVehiculoOfRespuestosNewRepuesto = respuestosNewRepuesto.getUnVehiculo();
                    respuestosNewRepuesto.setUnVehiculo(vehiculo);
                    respuestosNewRepuesto = em.merge(respuestosNewRepuesto);
                    if (oldUnVehiculoOfRespuestosNewRepuesto != null && !oldUnVehiculoOfRespuestosNewRepuesto.equals(vehiculo)) {
                        oldUnVehiculoOfRespuestosNewRepuesto.getRespuestos().remove(respuestosNewRepuesto);
                        oldUnVehiculoOfRespuestosNewRepuesto = em.merge(oldUnVehiculoOfRespuestosNewRepuesto);
                    }
                }
            }
            for (EstadoVehiculo estadosOldEstadoVehiculo : estadosOld) {
                if (!estadosNew.contains(estadosOldEstadoVehiculo)) {
                    estadosOldEstadoVehiculo.setUnVehiculo(null);
                    estadosOldEstadoVehiculo = em.merge(estadosOldEstadoVehiculo);
                }
            }
            for (EstadoVehiculo estadosNewEstadoVehiculo : estadosNew) {
                if (!estadosOld.contains(estadosNewEstadoVehiculo)) {
                    Vehiculo oldUnVehiculoOfEstadosNewEstadoVehiculo = estadosNewEstadoVehiculo.getUnVehiculo();
                    estadosNewEstadoVehiculo.setUnVehiculo(vehiculo);
                    estadosNewEstadoVehiculo = em.merge(estadosNewEstadoVehiculo);
                    if (oldUnVehiculoOfEstadosNewEstadoVehiculo != null && !oldUnVehiculoOfEstadosNewEstadoVehiculo.equals(vehiculo)) {
                        oldUnVehiculoOfEstadosNewEstadoVehiculo.getEstados().remove(estadosNewEstadoVehiculo);
                        oldUnVehiculoOfEstadosNewEstadoVehiculo = em.merge(oldUnVehiculoOfEstadosNewEstadoVehiculo);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = vehiculo.getNroChasis();
                if (findVehiculo(id) == null) {
                    throw new NonexistentEntityException("The vehiculo with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Vehiculo vehiculo;
            try {
                vehiculo = em.getReference(Vehiculo.class, id);
                vehiculo.getNroChasis();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The vehiculo with id " + id + " no longer exists.", enfe);
            }
            Garantia unaGarantia = vehiculo.getUnaGarantia();
            if (unaGarantia != null) {
                unaGarantia.setUnVehiculo(null);
                unaGarantia = em.merge(unaGarantia);
            }
            Turno unTurno = vehiculo.getUnTurno();
            if (unTurno != null) {
                unTurno.setUnVehiculo(null);
                unTurno = em.merge(unTurno);
            }
            Cliente unCliente = vehiculo.getUnCliente();
            if (unCliente != null) {
                unCliente.getVehiculos().remove(vehiculo);
                unCliente = em.merge(unCliente);
            }
            Set<PedidoRepuesto> pedidos = vehiculo.getPedidos();
            for (PedidoRepuesto pedidosPedidoRepuesto : pedidos) {
                pedidosPedidoRepuesto.setUnVehiculo(null);
                pedidosPedidoRepuesto = em.merge(pedidosPedidoRepuesto);
            }
            List<ReparacionEnEjecucion> reparacionesEnEjecucion = vehiculo.getReparacionesEnEjecucion();
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucion : reparacionesEnEjecucion) {
                reparacionesEnEjecucionReparacionEnEjecucion.setUnVehiculo(null);
                reparacionesEnEjecucionReparacionEnEjecucion = em.merge(reparacionesEnEjecucionReparacionEnEjecucion);
            }
            List<Repuesto> respuestos = vehiculo.getRespuestos();
            for (Repuesto respuestosRepuesto : respuestos) {
                respuestosRepuesto.setUnVehiculo(null);
                respuestosRepuesto = em.merge(respuestosRepuesto);
            }
            List<EstadoVehiculo> estados = vehiculo.getEstados();
            for (EstadoVehiculo estadosEstadoVehiculo : estados) {
                estadosEstadoVehiculo.setUnVehiculo(null);
                estadosEstadoVehiculo = em.merge(estadosEstadoVehiculo);
            }
            em.remove(vehiculo);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Vehiculo> findVehiculoEntities() {
        return findVehiculoEntities(true, -1, -1);
    }

    public List<Vehiculo> findVehiculoEntities(int maxResults, int firstResult) {
        return findVehiculoEntities(false, maxResults, firstResult);
    }

    private List<Vehiculo> findVehiculoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Vehiculo.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Vehiculo findVehiculo(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Vehiculo.class, id);
        } finally {
            em.close();
        }
    }

    public int getVehiculoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Vehiculo> rt = cq.from(Vehiculo.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
